class SparseAbsOpMaker : public framework::OpProtoAndCheckerMaker {
 public:
  void Make() override {
    AddInput("x", "(Tensor), input 0 of sparse_abs op.");
    AddOutput("out", "(Tensor), output 0 of sparse_abs op.");
    AddComment(R"DOC(
TODO: Documentation of sparse_abs op.
)DOC");
  }
};

template <typename T>
class SparseAbsGradOpMaker : public framework::SingleGradOpMaker<T> {
 public:
  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;

 protected:
  void Apply(GradOpPtr<T> grad_op) const override {
    grad_op->SetType("sparse_abs_grad");

    grad_op->SetInput("x", this->Input("x"));
    grad_op->SetInput(GradVarName("out"), this->OutputGrad("out"));

    grad_op->SetOutput(GradVarName("x"), this->InputGrad("x"));

    grad_op->SetAttrMap(this->Attrs());
  }
};

class SparseAbsOp : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;
};

DECLARE_INFER_SHAPE_FUNCTOR(sparse_abs, SparseAbsInferShapeFunctor,
                            PD_INFER_META(phi::UnchangedInferMeta));

REGISTER_OPERATOR(sparse_abs, ops::SparseAbsOp,
                  ops::SparseAbsOpMaker,
                  ops::SparseAbsGradOpMaker<paddle::framework::OpDesc>,
                  ops::SparseAbsGradOpMaker<paddle::imperative::OpBase>,
                  ops::SparseAbsInferShapeFunctor);

KernelSignature SparseAbsOpArgumentMapping(const ArgumentMappingContext& ctx) {
  paddle::small_vector<const char*> inputs {"x"};
  paddle::small_vector<const char*> attrs;
  paddle::small_vector<const char*> outputs {"out"};
  const char* kernel_name = "unregistered";

  if (ctx.IsSparseCooTensorInput("x")) {
    kernel_name = "abs_coo";
  }
  if (ctx.IsSparseCsrTensorInput("x")) {
    kernel_name = "abs_csr";
  }
  KernelSignature sig (kernel_name, std::move(inputs), std::move(attrs), std::move(outputs));
  return sig;
}

/*
******************************************************************
NOTE: The following codes are for 'get_compat_kernel_signature.py'
All possible KernelSignatures returned by SparseAbsOpArgumentMapping:

return KernelSignature("abs_coo", {"x"}, {}, {"out"});
return KernelSignature("abs_csr", {"x"}, {}, {"out"});
******************************************************************
*/

PD_REGISTER_ARG_MAPPING_FN(sparse_abs, phi::SparseAbsOpArgumentMapping);
PD_REGISTER_ARG_MAPPING_FN(sparse_abs_grad, phi::SparseAbsGradOpArgumentMapping);